home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Tech Arsenal 1
/
Tech Arsenal (Arsenal Computer).ISO
/
tek-01
/
cl182.zip
/
CL.HPF
< prev
next >
Wrap
Text File
|
1993-05-15
|
16KB
|
662 lines
/*
cl.hpf -- Container Lite v 1.82 "form template"
(C) Copyright 1993 John Webster Small
All rights reserved
*/
#ifndef cl_hpp
#include "cl.hpp"
#endif
#ifndef string_h
#include <string.h>
#define string_h
#endif
/* ITEM descriptors */
#if defined(ITEM_BINARY_STRM)
#if !defined(ITEM_BINARY_STRM_INSERT)
#define ITEM_BINARY_STRM_INSERT
#endif
#if !defined(ITEM_BINARY_STRM_EXTRACT)
#define ITEM_BINARY_STRM_EXTRACT
#endif
#endif
#if defined(ITEM_BINARY_CMP_STRM)
#if !defined(ITEM_BINARY_CMP)
#define ITEM_BINARY_CMP
#endif
#if !defined(ITEM_BINARY_STRM_INSERT)
#define ITEM_BINARY_STRM_INSERT
#endif
#if !defined(ITEM_BINARY_STRM_EXTRACT)
#define ITEM_BINARY_STRM_EXTRACT
#endif
#endif
#if defined(ITEM_NO_STRM_OPS)
#if !defined(ITEM_NO_STRM_INSERT)
#define ITEM_NO_STRM_INSERT
#endif
#if !defined(ITEM_NO_STRM_EXTRACT)
#define ITEM_NO_STRM_EXTRACT
#endif
#endif
#if defined(ITEM_NO_REL_STRM_OPS)
#if !defined(ITEM_NO_REL_OPS)
#define ITEM_NO_REL_OPS
#endif
#if !defined(ITEM_NO_STRM_INSERT)
#define ITEM_NO_STRM_INSERT
#endif
#if !defined(ITEM_NO_STRM_EXTRACT)
#define ITEM_NO_STRM_EXTRACT
#endif
#endif
#if defined(ITEM_DELETE_ONLY)
#if !defined(ITEM_NO_REL_OPS)
#define ITEM_NO_REL_OPS
#endif
#if !defined(ITEM_NO_ASSIGN)
#define ITEM_NO_ASSIGN
#endif
#if !defined(ITEM_NO_COPYINIT)
#define ITEM_NO_COPYINIT
#endif
#if !defined(ITEM_NO_STRM_INSERT)
#define ITEM_NO_STRM_INSERT
#endif
#if !defined(ITEM_NO_STRM_EXTRACT)
#define ITEM_NO_STRM_EXTRACT
#endif
#endif
#if defined(ITEM_BIND_ONLY)
#if !defined(ITEM_NO_REL_OPS)
#define ITEM_NO_REL_OPS
#endif
#if !defined(ITEM_NO_ASSIGN)
#define ITEM_NO_ASSIGN
#endif
#if !defined(ITEM_NO_COPYINIT)
#define ITEM_NO_COPYINIT
#endif
#if !defined(ITEM_NO_DELETE)
#define ITEM_NO_DELETE
#endif
#if !defined(ITEM_NO_STRM_INSERT)
#define ITEM_NO_STRM_INSERT
#endif
#if !defined(ITEM_NO_STRM_EXTRACT)
#define ITEM_NO_STRM_EXTRACT
#endif
#endif
#if defined(ITEM_STRMABLE) || defined(ITEM_STRM_BASE)
#if !defined(ITEM_STRM_BASE)
#define ITEM_STRM_BASE ITEM_STRMABLE
#endif
#if !defined(ITEM_TEST_ASSIGN)
#define ITEM_TEST_ASSIGN
#endif
#if !defined(ITEM_CLONE)
#define ITEM_CLONE
#endif
#if !defined(ITEM_STRM_MUT_DELETE)
#define ITEM_STRM_MUT_DELETE
#endif
#if !defined(ITEM_LINK)
#define ITEM_LINK
#endif
#if !defined(ITEM_UNLINK)
#define ITEM_UNLINK
#endif
#if !defined(ITEM_STRM_INSERT)
#define ITEM_STRM_INSERT
#endif
#if !defined(ITEM_STRM_EXTRACT)
#define ITEM_STRM_EXTRACT
#endif
#endif
#if defined(ITEM_str)
#if defined(ITEM)
#undef ITEM
#endif
#define ITEM char
#if !defined(CL)
#define CL CL_str
#endif
#endif
#if defined(ITEM_NO_REL_OPS)
inline CLcmP(CL_DcmP(CLcmP(cmP,ITEM)),void)
{ return CLcmPcast(cmP,void); }
#else
#if defined(ITEM_str)
// not really inline - gimmick to
// define function in header!
inline
int CL_Dcmp(const char * D1, const char * D2)
{ return strcmp(D1,D2); }
#elif defined(ITEM_BINARY_CMP)
#include <string.h> // memcmp()
// not really inline - gimmick to
// define function in header!
inline
int CL_Dcmp(const ITEM * D1, const ITEM * D2)
{ return memcmp(D1,D2,sizeof(ITEM)); }
#elif !defined(ITEM_CMP_DEF)
// not really inline - gimmick to
// define function in header!
inline
int CL_Dcmp(const ITEM * D1, const ITEM * D2)
{ return ((*D1 == *D2)? 0 : ((*D1 > *D2)? 1 : -1)); }
#endif
inline CLcmP(CL_DcmP(CLcmP(cmP,ITEM)),void)
{ CLcmP(defaultCmP,ITEM) = CL_Dcmp;
return CLcmPcast((cmP? cmP : defaultCmP),void); }
#endif
#if defined(ITEM_str)
inline void * CL_Dassign(char *,
const char *, unsigned)
{ return (void *)0; }
#elif defined(ITEM_TEST_ASSIGN)
inline void * CL_Dassign(ITEM * D,
const ITEM * S, unsigned)
{ return (void *)
((*D = *(const ITEM_STRM_BASE *)S)? D : 0); }
#elif defined(ITEM_NO_ASSIGN)
inline void * CL_Dassign(ITEM *,
const ITEM *, unsigned)
{ return (void *) 0; }
#elif !defined(ITEM_ASSIGN_DEF)
inline void * CL_Dassign(ITEM * D,
const ITEM * S, unsigned)
{ *D = *S; return (void *) D; }
#endif
#if defined(ITEM_str)
inline void * CL_Dnew(const ITEM * D)
{ return strdup(D); }
#elif defined(ITEM_CLONE)
inline void * CL_Dnew(const ITEM * D)
{ return (void *) D->clone(); }
#elif defined(ITEM_NO_COPYINIT)
inline void * CL_Dnew(const ITEM *)
{ return (void *) 0; }
#elif !defined(ITEM_COPYINIT_DEF)
inline void * CL_Dnew(const ITEM * D)
{ return (void *) new ITEM(*D); }
#endif
#if defined(ITEM_STRM_MUT_DELETE)
inline void CL_Ddelete(ITEM * D)
{ if (!D->RefCount()) delete D; }
#elif defined(ITEM_NO_DELETE)
inline void CL_Ddelete(ITEM *)
{ return; }
#elif !defined(ITEM_DELETE_DEF)
inline void CL_Ddelete(ITEM *D)
{ delete D; }
#endif
#if defined(ITEM_LINK)
inline int CL_Dattach(ITEM * D,
const void * B)
{ return D->link(B); }
#elif !defined(ITEM_LINK_DEF)
inline int CL_Dattach(ITEM *,
const void *)
{ return 1; }
#endif
#if defined(ITEM_UNLINK)
inline void CL_Ddetach
(ITEM * D, const void * B)
{ D->unlink(B); }
#elif !defined(ITEM_UNLINK_DEF)
inline void CL_Ddetach(ITEM*,
const void *) {}
#endif
#if defined(ITEM_STRM_INSERT)
inline ostream& operator<<(ostream& os,
ITEM ** D)
{ return os << *(ITEM_STRM_BASE *)*D; }
#elif defined(ITEM_NO_STRM_INSERT)
inline ostream& operator<<(ostream& os,
ITEM **) { return os; }
#elif defined(ITEM_BINARY_STRM_INSERT)
inline ostream& operator<<(ostream& os,
ITEM ** D)
{ return os.write((char *)*D,sizeof(ITEM)); }
#elif !defined(ITEM_STRM_INSERT_DEF) && !defined(ITEM_str)
inline ostream& operator<<(ostream& os,
ITEM ** D)
{ return os << **D << endm; }
#endif
inline ostream& operator<<(ostream& os, char ** D)
{
int len = (*D? strlen(*D) : 0);
if ((os << len << endm))
if (len)
os.write(*D,len);
return os;
}
#if defined(ITEM_STRM_EXTRACT)
inline istream& operator>>(istream& is,
ITEM ** D)
{
ITEM_STRM_BASE * S;
is >> S;
if (*D) delete *D;
*D = (ITEM *) S;
return is;
}
#elif defined(ITEM_NO_STRM_EXTRACT)
inline istream& operator>>(istream& is,
ITEM **) { return is; }
#elif defined(ITEM_BINARY_STRM_EXTRACT)
inline istream& operator>>(istream& is,
ITEM ** D)
{
if (*D) delete *D;
if ((*D = new ITEM) != (ITEM *)0)
return is.read((char *)*D,sizeof(ITEM));
return is;
}
#elif !defined(ITEM_STRM_EXTRACT_DEF) && !defined(ITEM_str)
inline istream& operator>>(istream& is,
ITEM ** D)
{
if (*D) delete *D;
if ((*D = new ITEM) != (ITEM *)0)
is >> **D >> nextm;
return is;
}
#endif
inline istream& operator>>(istream& is, char ** D)
{
int len;
if (*D) {
delete *D;
*D = (char *)0;
}
if ((is >> len >> nextm))
if (len)
if ((*D = new char[len+1])
!= (char *)0) {
is.read(*D,len);
(*D)[len] = '\0';
}
else
is.ignore(len);
return is;
}
class CL : cl {
protected:
CL (defaultConstructor)
: cl(defaultConstruct) {}
void assign(const CL& b)
{ cl::assign(b); }
cl:: destruct;
virtual voidCmP DcmP(voidCmP cmP)
{ return CLcmPcast(CL_DcmP
(CLcmPcast(cmP,ITEM)),void); }
virtual void * Dassign(void * D,
const void * S)
{ return CL_Dassign
((ITEM *)D,(const ITEM *)S,
flags); }
virtual void * Dnew(const void * D)
{ return CL_Dnew
((const ITEM *)D); }
virtual void Ddelete(void * D)
{ CL_Ddelete((ITEM *)D); }
virtual int Dattach(void * D)
{ return CL_Dattach((ITEM *)D,
(const void *) this); }
virtual void Ddetach(void * D)
{ CL_Ddetach((ITEM *)D,
(const void *) this); }
virtual int Dput(ostream& os, void * D)
{ return ((os << (ITEM **) &D)?
1 : 0); }
virtual void * Dget(istream& is)
{ ITEM * D = 0; is >> &D;
return (void *) D; }
virtual int put(ostream& os)
{ return cl::put(os); }
virtual int get(istream& is)
{ return cl::get(is); }
friend ostream& operator<<(ostream& os,
CL& b);
friend istream& operator>>(istream& is,
CL& b);
cl:: vforEach;
public:
/* Constructors and destructor */
CL (unsigned flags = CL_BIND_ONLY,
unsigned maxNodes = CL_MAXNODES,
unsigned limit = CL_LIMIT,
unsigned delta = CL_DELTA) :
cl(flags,maxNodes,limit,delta)
{}
CL (ITEM * argv[],
unsigned argc = 0U,
unsigned flags = CL_BIND_ONLY)
: cl((void **)argv,argc,flags)
{}
CL (CL& b) : cl(defaultConstruct)
{ assign(b); }
CL& operator=(CL& b)
{ assign(b); return *this; }
int operator==(const CL& b) const
{ return cl::operator==(b); }
int operator> (const CL& b) const
{ return cl::operator>(b); }
CL (const char * filename)
: cl(defaultConstruct)
{ (void) cl::load(filename); }
int load(const char * filename)
{ return cl::load(filename); }
int save(const char * filename)
{ return cl::save(filename); }
ITEM ** vector(ITEM ** argv = (ITEM **)0,
unsigned argc = 0U) const
{ return (ITEM **)cl::
vector((void **)argv,argc); }
virtual ~CL() { destruct(); }
/* Housekeeping Primitives */
cl:: Limit;
cl:: setLimit;
cl:: pack;
cl:: Delta;
cl:: setDelta;
cl:: Nodes;
cl:: MaxNodes;
cl:: setMaxNodes;
cl:: vacancy;
cl:: vacancyNonElastic;
cl:: Flags;
cl:: setFlags;
cl:: resetFlags;
CL& operator<<(CL&
(*manipulator)(CL&))
{ return (manipulator?
(*manipulator)
(*this) : *this); }
/* Elastic Array Primitives */
ITEM * atIns(unsigned n, ITEM * D)
{ return (ITEM *)cl::
atIns(n,(void *)D); }
ITEM * atInsNew(unsigned n, const ITEM * D)
{ return (ITEM *)cl::
atInsNew(n,(const void *)D); }
ITEM * atRmv(unsigned n)
{ return (ITEM *)cl::
atRmv(n); }
cl:: allRmv;
cl:: atDel;
ITEM * atDelAsg(unsigned n, ITEM * D)
{ return (ITEM *)cl::
atDelAsg(n,(void *)D); }
cl:: allDel;
cl:: allClr;
ITEM * atPut(unsigned n, ITEM * D)
{ return (ITEM *)cl::
atPut(n,(void *)D); }
ITEM * atPutNew(unsigned n, const ITEM * D)
{ return (ITEM *)cl::
atPutNew(n,(const void *)D); }
ITEM * atPutAsg(unsigned n, const ITEM * D)
{ return (ITEM *)cl::
atPutAsg(n,(const void *)D); }
ITEM * atGet(unsigned n) const
{ return (ITEM *)cl::
atGet(n); }
ITEM * operator[](unsigned n) const
{ return atGet(n); }
ITEM * atGetAsg(unsigned n, ITEM * D)
{ return (ITEM *)cl::
atGetAsg(n,(void *) D); }
ITEM * atXchg(unsigned n, ITEM * D)
{ return (ITEM *)cl::
atXchg(n,(void *) D); }
unsigned index(const ITEM * D) const
{ return cl::
index((const void *)D); }
void forEach(CLapplY(B,ITEM), ...)
{ va_list args;
va_start(args,B);
vforEach((voidApplY)B,args);
va_end(args); }
/* Stack - Deque - Queue Primitives */
ITEM * push(ITEM * D)
{ return (ITEM *)cl::
push((void *) D); }
ITEM * pushNew(const ITEM * D)
{ return (ITEM *)cl::
pushNew((const void *)D); }
ITEM * pop()
{ return (ITEM *)cl::
pop(); }
CL& operator>>(ITEM *& D)
{ D = atRmv(0U);
return *this; }
cl:: popDel;
ITEM * popDelAsg(ITEM * D)
{ return (ITEM *)cl::
popDelAsg((void *)D); }
ITEM * top() const
{ return (ITEM *)cl::
top(); }
ITEM * topAsg(ITEM * D)
{ return (ITEM *)cl::
topAsg((void *)D); }
ITEM * insQ(ITEM * D)
{ return (ITEM *)cl::
insQ((void *)D); }
CL& operator<<(ITEM * D)
{ atIns(Nodes(),D);
return *this; }
ITEM * insQNew(const ITEM * D)
{ return (ITEM *)cl::
insQNew((const void *)D); }
ITEM * unQ()
{ return (ITEM *)cl::
unQ(); }
cl:: unQDel;
ITEM * unQDelAsg(ITEM * D)
{ return (ITEM *)cl::
unQDelAsg((void *)D); }
ITEM * rear() const
{ return (ITEM *)cl::
rear(); }
ITEM * rearAsg(ITEM * D)
{ return (ITEM *)cl::
rearAsg((void *)D); }
/* List (single and double linked) Primitives */
cl:: CurNode;
cl:: setCurNode;
ITEM * ins(ITEM * D)
{ return (ITEM *)cl::
ins((void *)D); }
ITEM * insNew(const ITEM * D)
{ return (ITEM *)cl::
insNew((const void *)D); }
ITEM * rmv()
{ return (ITEM *)cl::
rmv(); }
cl:: del;
ITEM * delAsg(ITEM * D)
{ return (ITEM *)cl::
delAsg((void *)D); }
ITEM * put(ITEM * D)
{ return (ITEM *)cl::
put((void *)D); }
ITEM * putNew(const ITEM * D)
{ return (ITEM *)cl::
putNew((const void *)D); }
ITEM * putAsg(const ITEM * D)
{ return (ITEM *)cl::
putAsg((const void *)D); }
ITEM * get() const
{ return (ITEM *)cl::
get(); }
operator ITEM *() const { return get(); }
ITEM * getAsg(ITEM * D)
{ return (ITEM *)cl::
getAsg((void *)D); }
ITEM * next()
{ return (ITEM *)cl::
next(); }
ITEM * operator++()
{ return next(); }
ITEM * nextAsg(ITEM * D)
{ return (ITEM *)cl::
nextAsg((void *)D); }
ITEM * prev()
{ return (ITEM *)cl::
prev(); }
ITEM * operator--()
{ return prev(); }
ITEM * prevAsg(ITEM * D)
{ return (ITEM *)cl::
prevAsg((void *)D); }
/* Priority Q, Set, Bag, Dictionary, Sort Primitives */
cl:: Sorted;
cl:: unSort;
void setCmP(CLcmP(cmP,ITEM)
= CLcmP0(ITEM))
{ cl::setCmP
((voidCmP)cmP); }
CLcmP(CmPfnc,ITEM) { return CLcmPcast
(cl::CmP(),ITEM); }
int sort(CLcmP(cmP,ITEM)
= CLcmP0(ITEM))
{ return cl::sort
((voidCmP)cmP); }
ITEM * insSort(ITEM * D)
{ return (ITEM *)cl::
insSort((void *)D); }
ITEM * insSortNew(const ITEM * D)
{ return (ITEM *)cl::
insSortNew((const void *)D); }
ITEM * insUnique(ITEM * D)
{ return (ITEM *)cl::
insUnique((void *)D); }
ITEM * insUniqueNew(const ITEM * D)
{ return (ITEM *)cl::
insUniqueNew((const void *)D);}
ITEM * findFirst(const ITEM * K)
{ return (ITEM *)cl::
findFirst((const void *)K); }
ITEM * operator[](const ITEM * K)
{ return findFirst(K); }
ITEM * findNext(const ITEM * K)
{ return (ITEM *)cl::
findNext((const void *)K); }
ITEM * findLast (const ITEM * K)
{ return (ITEM *)cl::
findLast((const void *)K); }
ITEM * findPrev(const ITEM * K)
{ return (ITEM *)cl::
findPrev((const void *)K); }
unsigned findAll(const ITEM * K)
{ return cl::
findAll((const void *)K); }
}; /* class CL */
inline ostream& operator<<(ostream& os, CL& b)
{ (void) b.put(os); return os; }
inline istream& operator>>(istream& is, CL& b)
{ (void) b.get(is); return is; }
#undef ITEM
#undef CL
#undef ITEM_BINARY_CMP
#undef ITEM_BINARY_STRM_INSERT
#undef ITEM_BINARY_STRM_EXTRACT
#undef ITEM_BINARY_STRM
#undef ITEM_BINARY_CMP_STRM
#undef ITEM_CMP_DEF
#undef ITEM_ASSIGN_DEF
#undef ITEM_COPYINIT_DEF
#undef ITEM_DELETE_DEF
#undef ITEM_LINK_DEF
#undef ITEM_UNLINK_DEF
#undef ITEM_STRM_INSERT_DEF
#undef ITEM_STRM_EXTRACT_DEF
#undef ITEM_NO_STRM_OPS
#undef ITEM_NO_REL_STRM_OPS
#undef ITEM_DELETE_ONLY
#undef ITEM_NO_REL_OPS
#undef ITEM_NO_ASSIGN
#undef ITEM_NO_COPYINIT
#undef ITEM_NO_STRM_INSERT
#undef ITEM_NO_STRM_EXTRACT
#undef ITEM_BIND_ONLY
#undef ITEM_NO_DELETE
#undef ITEM_STRMABLE
#undef ITEM_TEST_ASSIGN
#undef ITEM_CLONE
#undef ITEM_STRM_MUT_DELETE
#undef ITEM_LINK
#undef ITEM_UNLINK
#undef ITEM_STRM_INSERT
#undef ITEM_STRM_EXTRACT
#undef ITEM_STRM_BASE
#undef ITEM_str